/*
 * @Description: In User Settings Edit
 * @Author: xiaoying
 * @Date: 2019-09-04 17:03:54
 * @LastEditTime: 2019-09-19 16:03:24
 * @LastEditors: mayuanye
 */
import { NativeModules } from 'react-native';
import Dot3D from './Dot3D.js';
let MD = NativeModules.JSModel;

/**
 * @class Model
 * @description 模型对象，此类中包含了模型可见(STATE_UNVISIBLE)与不可见(STATE_VISIBLE)两种常量
 *
 * @property {int} State.STATE_UNVISIBLE  0 - 模型可见性：不可见
 * @property {int} State.STATE_VISIBLE    1 - 模型可见性：可见
 */
export default class Model {
  /**
   * 创建一个新的Model对象
   *
   * @memberof Model
   * @returns {Promise<Model>}
   */
  async createObj() {
    try {
      var { ModelId } = await MD.createObj();
      var model = new Model();
      model._MGModelId = ModelId;
      return model;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置图形的可见状态.
   *
   * @memberof Model
   * @param {int} state 模型的可见状态 ,取值为STATE_UNVISIBLE和STATE_VISIBLE两种.
   * @returns {Promise<Void>}
   */
  async setState(state) {
    try {
      await MD.setState(this._MGModelId, state);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取图形的可见状态.
   *
   * @memberof Model
   * @returns {int}  模型的可见状态 ,取值为STATE_UNVISIBLE和STATE_VISIBLE两种.
   */
  async getState() {
    try {
      let state = await MD.getState(this._MGModelId);
      return state;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置名称
   *
   * @memberof Model
   * @param {String} name 名称
   * @returns {Promise<Void>}
   */
  async setName(name) {
    try {
      await MD.setName(this._MGModelId, name);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取名称
   * @memberof Model
   * @returns {String} 名称
   */
  async getName() {
    try {
      let name = await MD.getName(this._MGModelId);
      return name;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置模型位置
   *
   * @memberof Model
   * @param {Object} position 位置 (Object-Dot3D)
   * @returns {Promise<Void>}
   */
  async setPosition(position) {
    try {
      await MD.setPosition(this._MGModelId, position._MGDot3DId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取模型位置
   *
   * @memberof Model
   * @returns {Promise<Dot3D>} 模型位置
   */
  async getPosition() {
    try {
      var { Dot3DId } = await MD.getPosition(this._MGModelId);
      var dot3D = null;
      if (Dot3DId != null) {
        dot3D = new Dot3D();
        dot3D._MGDot3DId = Dot3DId;
      }
      return dot3D;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置模型在x轴方向上的缩放比
   *
   * @memberof Model
   * @param {double} scale 缩放比
   * @returns {Promise<Void>}
   */
  async setScaleX(scale) {
    try {
      await MD.setScaleX(this._MGModelId, scale);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取模型在x轴方向上的缩放比
   *
   * @memberof Model
   * @returns {double} 缩放比
   */
  async getScaleX() {
    try {
      let scale = await MD.getScaleX(this._MGModelId);
      return scale;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置模型在y轴方向上的缩放比
   *
   * @memberof Model
   * @param {double} scale 缩放比
   * @returns {Promise<Void>}
   */
  async setScaleY(scale) {
    try {
      await MD.setScaleY(this._MGModelId, scale);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取模型在y轴方向上的缩放比
   *
   * @memberof Model
   * @returns {double} 缩放比
   */
  async getScaleY() {
    try {
      let scale = await MD.getScaleY(this._MGModelId);
      return scale;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置模型在z轴方向上的缩放比
   *
   * @memberof Model
   * @param {double} scale 缩放比
   * @returns {Promise<Void>}
   */
  async setScaleZ(scale) {
    try {
      await MD.setScaleZ(this._MGModelId, scale);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取模型在z轴方向上的缩放比
   *
   * @memberof Model
   * @returns {double} 缩放比
   */
  async getScaleZ() {
    try {
      let scale = await MD.getScaleZ(this._MGModelId);
      return scale;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置模型绕x轴旋转的角度
   *
   * @memberof Model
   * @param {float} angle 角度
   * @returns {Promise<Void>}
   */
  async setAngleAroundX(angle) {
    try {
      await MD.setAngleAroundX(this._MGModelId, angle);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取模型绕x轴旋转的角度
   *
   * @memberof Model
   * @returns {float} 角度
   */
  async getAngleAroundX() {
    try {
      let angleAroundX = await MD.getAngleAroundX(this._MGModelId);
      return angleAroundX;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置模型绕y轴旋转的角度
   *
   * @memberof Model
   * @param {float} angle 角度
   * @returns {Promise<Void>}
   */
  async setAngleAroundY(angle) {
    try {
      await MD.setAngleAroundY(this._MGModelId, angle);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取模型绕y轴旋转的角度
   *
   * @memberof Model
   * @returns {float} 角度
   */
  async getAngleAroundY() {
    try {
      let angleAroundY = await MD.getAngleAroundY(this._MGModelId);
      return angleAroundY;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置模型绕z轴旋转的角度
   *
   * @memberof Model
   * @param {float} angle 角度
   * @returns {Promise<Void>}
   */
  async setAngleAroundZ(angle) {
    try {
      await MD.setAngleAroundZ(this._MGModelId, angle);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取模型绕z轴旋转的角度
   *
   * @memberof Model
   * @returns {float} 角度
   */
  async getAngleAroundZ() {
    try {
      let angleAroundZ = await MD.getAngleAroundZ(this._MGModelId);
      return angleAroundZ;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置是否显示包围盒
   *
   * @memberof Model
   * @param {boolean} show 是否显示包围盒
   * @returns {Promise<Void>}
   */
  async setShowBoundingBox(show) {
    try {
      await MD.setShowBoundingBox(this._MGModelId, show);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 是否显示包围盒
   *
   * @memberof Model
   * @returns {boolean} 是否显示
   */
  async isShowBoundingBox() {
    try {
      let result = await MD.isShowBoundingBox(this._MGModelId);
      return result;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 从单个模型文件中加载数据(默认格式为mm3d)
   *
   * @memberof Model
   * @param {String} strModelFile 单个模型文件
   * @returns {boolean} true-成功 ； false-失败
   */
  async loadDataFromFile(strModelFile) {
    try {
      let result = await MD.loadDataFromFile(this._MGModelId, strModelFile);
      return result;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 保存模型数据到指定的单个模型文件中(默认格式为mm3d)
   *
   * @memberof Model
   * @param {String} strModelFile 单个模型文件
   * @returns {boolean} true-成功 ； false-失败
   */
  async saveDataToFile(strModelFile) {
    try {
      let result = await MD.saveDataToFile(this._MGModelId, strModelFile);
      return result;
    } catch (e) {
      console.error(e);
    }
  }
}

Model.State = {
  // 模型可见性：不可见
  STATE_UNVISIBLE: 0,
  // 模型可见性：可见
  STATE_VISIBLE: 1,
};
